﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using SistemaBastanteo.Persistencia;
using SistemaBastanteo.Dominio;
using NUnit.Framework;

namespace SistemaBastanteo.Pruebas
{
    public class Test04_Poder
    {
        IPoderDAO poderDAO = null; // Utilizamos una referencia a la interfaz
        Poder poderCreado= null;

        [TestFixtureSetUp]
        public void InicializarPruebas()
        {
            poderDAO = new Persistencia.NH.PoderDAO(); // Elegimos la implementación DAO a probar (ADO ó NHibernate)
            foreach (Poder poder in poderDAO.ListarTodos())
                poderDAO.Eliminar(poder);
        }

        [Test]
        public void Test1_Crear()
        {
            Poder poderACrear = new Poder();
            // 1. Validar que ocurra un error si no se ingresa algun valor obligatorio en Poder
            poderACrear.CodigoCorto = null;
            poderACrear.Descripcion = null;
            Assert.Catch<Exception>(delegate
            {
                poderCreado = poderDAO.Crear(poderACrear);
            });
            // 2. Validar que se crea correctamente (sin error) el poder
            poderACrear.CodigoCorto = "CHCO"; 
            poderACrear.Descripcion = "Cobro de Cheque";
            poderACrear.TipoProducto = "Activo";
            Assert.DoesNotThrow(delegate
            {
                poderCreado = poderDAO.Crear(poderACrear);
            });
            // 3. Validar que el poder creado no sea nulo, y su c|odigo sea mayor que 0, y  que codigo corto sea el ingresado
            Assert.IsNotNull(poderCreado);
            Assert.Greater(poderCreado.Codigo, 0);
            Assert.AreEqual(poderCreado.CodigoCorto, poderACrear.CodigoCorto);

            // 4. Validar que ocurra error si se registra un codigo corto de Poder  ya existente
            Poder poderNuevo = new Poder();
            poderNuevo.CodigoCorto = "CHCO";
            poderNuevo.Descripcion = "Retiro de efectivo";
            poderNuevo.TipoProducto = "Pasivo";
            
            Poder poderDuplicado = null;
            Assert.Catch<Exception>(delegate
            {
                poderDuplicado = poderDAO.Crear(poderNuevo);
            });

            Assert.IsNull(poderDuplicado);
        }
        
        [Test]
        public void Test2_Obtener()
        {
            Poder obtenido = null;
            // 1. Validar que si se intenta obtener un poder inexistente se retorne null
            Assert.DoesNotThrow(delegate
            {
                obtenido = poderDAO.Obtener(999);
            });
            Assert.IsNull(obtenido);
            // 2. Validar que se obtenga un poder correctamente (sin error)
            Assert.DoesNotThrow(delegate
            {
                obtenido = poderDAO.Obtener(poderCreado.Codigo);
            });
            Assert.IsNotNull(obtenido);
        }
        [Test]
        public void Test3_Modificar()
        {
            Poder poderAModificar = poderDAO.Obtener(poderCreado.Codigo);
            Poder poderModificado = null;
            // 1. Validar que ocurre un error si los datos  ingresados son nulos
            poderAModificar.Descripcion = null;
            Assert.Catch<Exception>(delegate
            {
                poderModificado = poderDAO.Modificar(poderAModificar);
            });
            // 2. Validar que se modifica correctamente (sin error) el Poder
            poderAModificar.Descripcion = "Retiro de Efectivo";
            poderAModificar.TipoProducto = "Pasivo";
            Assert.DoesNotThrow(delegate
            {
                poderModificado = poderDAO.Modificar(poderAModificar);
            });
            // 3. Validar que el tipo de documento modificado no sea nulo y la Descripcion sea la ingresada
            Assert.IsNotNull(poderModificado);
            Assert.AreEqual(poderAModificar.Descripcion, poderModificado.Descripcion);
            Assert.AreEqual(poderAModificar.TipoProducto, poderModificado.TipoProducto);
        }
        [Test]
        public void Test4_Eliminar()
        {
            Poder poderAEliminar = poderDAO.Obtener(poderCreado.Codigo);
            // 1. Validar que ocurra un error si se intenta eliminar un poder nulo
            Assert.Catch<Exception>(delegate
            {
                poderDAO.Eliminar(null);
            });
            // 2. Validar que se elimine un poder correctamente
            Assert.DoesNotThrow(delegate
            {
                poderDAO.Eliminar(poderAEliminar);
            });
            // 3. Validar que el modelo eliminado ya no exista
            Poder poderEliminado = poderDAO.Obtener(poderCreado.Codigo);
            Assert.IsNull(poderEliminado);
        }
        [Test]
        public void Test5_Listar()
        {
            poderDAO.Crear(new Poder() { CodigoCorto = "CHCO", Descripcion  = "Cobro de Cheque",    TipoProducto = "Activo"});
            poderDAO.Crear(new Poder() { CodigoCorto = "EFRET", Descripcion = "Retiro de efectivo", TipoProducto = "Pasiva" });	
            // 1. Validar que se listen sin errores los tipos de empresa creados
            ICollection<Poder> poderesExistentes = null;
            Assert.DoesNotThrow(delegate
            {
                poderesExistentes = poderDAO.ListarTodos();
            });
            // 2. Validar que retorne los 2 poderes creados
            Assert.GreaterOrEqual(poderesExistentes.Count, 2);
            // 3. Validar que la Descripcion de cada poder no sea nula
            foreach (Poder tipo in poderesExistentes)
                Assert.IsNotNull(tipo.Descripcion);
        }
        
        [TestFixtureTearDown]
        public void FinalizarPruebas()
        {
            foreach (Poder poder in poderDAO.ListarTodos())
                poderDAO.Eliminar(poder);
            Persistencia.NH.NHibernateHelper.CerrarFabrica();
        }

    }
}